Copyright ©2002 by David Matuszek; Preveo i preradio: Goran Šuković
JavaScript je jezik koji se koristi na HTML (Web) stranicama za dodavanje interaktivnosti. Razumije ga večina browser-a. Implementacija zavisi od browser-a, pa često sadrži greške. Ovdje će biti opisna verzija JavaScript 1.5, poznata pod nazivom ECMA v3. Uglavnom će biti opisane stvari koje se nezavisne od platforme, bez pokušaja da opisujemo šta neće raditi u pojedinim browser-ima.
Kako se JavaScript koristi ekskluzivno na veb-stranicama, on ima ograničene sposobnosti pritupa datotekama i mreži. Jedina mogućnost kreiranja grafike je da kreira HTML kod programski.
Preporučena knjiga je, JavaScript:The Definitive Guide, autora Davida Flanigana, izdavač O'Reilly.
JavaScript ima tri primitivna tipa: broj (number)
, string
,
and boolean
.Sve ostalo je objekat
.
Broj (number)
može biti zapisan kao integer ili real; bez obzira na zapis,
brojevi se čuvaju kao floating-point. Specijalni predefinisnai brojevi su
Infinity
, NaN
("not a number"), Number.NaN
(isto kao NaN
), Number.MIN_VALUE
, Number.MAX_VALUE
,
Number.NEGATIVE_INFINITY
, and Number.POSITIVE_INFINITY
(isto kao Infinity
). Hexksadecimalni literali počinju sa 0x
ili 0X
. Nenulti brojevi se ne pišu sa vodećom nulom (npr. 0123
), jer će neke implementacije ovo tretirati kao oktalni broj.
String
je niz nula ili više karaktera imeđu jednostrukih ('hello'
) ili dvostrukih ("hello"
) navodnika.
Ne postoji "character" tip podataka. Specijalni karakteri su:
\0 |
NUL | \r |
carriage return | \' |
single quote | ||
\b |
backspace | \t |
horizontal tab | \" |
double quote | ||
\f |
form feed | \v |
vertical tab | \xDD |
Unicode hex DD | ||
\n |
newline | \\ |
backslash | \xDDDD |
Unicode hex DDDD |
Boolean
ima samo dvije vrijednostiČ true
ili false
.
Kada se vrši konverzija drugih tipova u boolean
(obično kod testiranja u naredbama uslovnog skoka), vrijednosti 0
, "0"
, prazan string (empty
string), undefined
, null
i NaN
konvertuju se u false
, a ostale vrijesnoti konvertuju se u true
.
Objekat (object)
je kolekcija imenovanih vrijednosti koje nazivamo
svojstvima (properties).
Ako je im svosjtva poznato porgrameru , može mu se pristupati "taćka-notacijom" object
.
property_name
, npr.image.width
.
Ako se ime može izračunati, koristi se sintaksa object[expression]
, npr.
image["width"]
. Specijalna vrijednost null
je objekat bez svojstava.
Slično, undefined
znači da promjenljivoj nije zadata vrijednost ili da svojstvo ne postoji.
Funkcije, nizovi, regularni izrazi, greške(errors) i dateumi su specijalni tipovi
za object
. Pored njih, postoje tzv. "wrapper" tipovi Number
,
String
i Boolean
, da bi imali mogučnost objektno-orijentisanih operacija nad primitivnm tipovima. JavaScript automatski vrši koverziju između primitiva i wrapper-a po potrebi, pa programer skoro nikad ne vidi wrapper tipove.
Identifikatori se sastoje od slova (definisanih u Unicodu), cifara, underscores, i/ili znaka dollar; prvi karakter ne može biti cifra. JavaScripte je Case-sensitive, ali HTML nije; kako se JavaScript imena često koriste u HTML-u, ovo često vodi do veoma neobičnih grešaka. Po konvenciji, imena promjenljivih, svojstava, funkcija i metoda počinju malim slovom; imena konstruktora počinju velikim slovom. Imena mogu biti proizvoljne dužine.
Slijedi spisak ključnih riječi JavaScript-a, i one se ne mogu koristiti kao imena. Kurzivom su označene riječi koje se trenutno ne koriste.
abstract
debugger
goto
int
public
switch
boolean
default
final
instanceof
return
synchronized
break
delete
finally
interface
throw
this
byte
do
float
long
throws
typeof
case
double
if
native
transient
var
catch
else
implements
new
true
void
char
enum
import
null
try
volatile
class
export
in
package
short
while
const
extends
for
private
static
with
continue
false
function
protected
super
//
označava komentar do kraja linije. Komentar u više linija počinje
sa /*
i završava sa */
. Unutar komentara, simboli
//
i /*
nemaju speijalno značenje (pa se komenatri ne mogu "ugnježdavati"
). Unutar stringa ili regularnog izraza, //
i
/*
ne predstavljaju komentar.
JavaScript promjenljive su untyped: svaka promjenljiva može čuvati vrijednost bilo kog tipa.
Promjenljive deklarišemo pomoću ključne riječi var
, zajedno sa opcionalnom
početnom vrijednosđću; npr.
ili
. Promjenljive može biti deklarisan i običnim dodjeljivanjem vrijednosti, npr.
x = 5
Ako je promjenljiva deklarisan ali joj nije dodijeljena vrijednost, ona ima specijalnu
vrijdnost undefined
; upotreba ove vrijednosti nije greška.
Ako promjenljiva nikada nije deklarisana, jeste greška pokušaj korišćenja njene vrijednosti.
Promjenljiva deklarisna sa var
unutra funkcije je lokalna za
tu funkciju, i može se koristiti bilo gdje unutar funkcije (čak i prije tačke u kojoj je deklarisana).
Ako je promjenljiva deklarisana van funkcije ili je deklarisana bez ključne riječi var
,
onda je globalna i može joj se pristupiti sa bilo kog mjesta u HTML dokumentu. Formalni parametri funkcije se tretiraju kao lokalne promjenljive. Ako lokalna promjenljiva ima isto ime kao globalna promjenljiva, tada se ime odnosi na lokalnu promjenljivu.
Where declared How declared Scope Within a function As a formal parameter Local to the function With var
Local to the function By assignment Global Not within a function With var
Global By assignment Global
Jedini opsezi (scopes) u JavaScript-u su global i "local to the function".
Promjenljiva može biti deklarisana u for
naredbi, tj.
Funkcije se mogu ugnježdavati, tj. funkcija može biti definisana unutar (i lokalna je ) druge funkcije. Promjenljiva deklarisna unutra ugnježdene funkcije lokalna je najbližoj funkciji u kojoj se nalazi.
Promjenljive su u stvari svojstva objekta. Globalne promjenljive su svojstva globalnih objekata. Promjenljive funkcije (function variables) su svojstva call objekta koji ima kratak život.
Operatori |
Značenje |
Pozicija |
Prioritet |
Asocijativnost |
---|---|---|---|---|
function_name (args)
|
Call the function | postfix | 15 | left to right |
array_name [index]
|
Index into the array | postfix | 15 | left to right |
object . property
|
The property of the object | infix | 15 | left to right |
new constructor |
Call the constructor | prefix | 15 | right to left |
! |
Boolean negation (true <--> false) | prefix | 14 | right to left |
~ |
Bitwise negation (change every bit) | prefix | 14 | right to left |
++ |
Add one | prefix or postfix | 14 | right to left |
-- |
Subtract one | prefix or postfix | 14 | right to left |
+ |
Unary plus (does nothing) | prefix | 14 | right to left |
- |
Unary minus (negation) | prefix | 14 | right to left |
delete |
Remove a property | prefix | 14 | right to left |
typeof |
Return data type | prefix | 14 | right to left |
void |
Return undefined |
prefix | 14 | right to left |
* |
Multiply | infix | 13 | left to right |
/ |
Floating-point divide | infix | 13 | left to right |
% |
Remainder | infix | 13 | left to right |
+ |
Add (numbers) or concatenate (strings) |
infix | 12 | left to right |
- |
Subtract | infix | 12 | left to right |
<< |
Shift bits left, vacated bits are set to zero | infix | 11 | left to right |
>> |
Shift bits right, vacated bits are set to sign bit | infix | 11 | left to right |
>>> |
Shift bits right, vacated bits are set to zero | infix | 11 | left to right |
< |
Less than | infix | 10 | left to right |
<= |
Less than or equal to | infix | 10 | left to right |
> |
Greater than | infix | 10 | left to right |
>= |
Greater than or equal to | infix | 10 | left to right |
instanceof |
Test type of left operand | infix | 10 | left to right |
in |
Test if property exists | infix | 10 | left to right |
== |
Equal to | infix | 9 | left to right |
!= |
Not equal to | infix | 9 | left to right |
=== |
Strictly equal to | infix | 9 | left to right |
!== |
Not strictly equal to | infix | 9 | left to right |
& |
Bitwise AND | infix | 8 | left to right |
^ |
Bitwise exclusive OR | infix | 7 | left to right |
| |
Bitwise OR | infix | 6 | left to right |
&& |
Boolean AND | infix | 5 | left to right |
|| |
Boolean OR | infix | 4 | left to right |
cond ? expr1
: expr2 |
If cond is true then expr1, else expr2 | double infix | 3 | right to left |
= |
Assignment, "gets" | infix | 2 | right to left |
+= |
Addition assignment operator: a+=b is the same as a=a+b
|
infix | 2 | right to left |
-= |
Subtraction assignment operator | infix | 2 | right to left |
*= |
Multiplication assignment operator | infix | 2 | right to left |
/= |
Division assignment operator | infix | 2 | right to left |
%= |
Remainder assignment operator | infix | 2 | right to left |
&= |
Bitwise AND assignment operator | infix | 2 | right to left |
^= |
Bitwise exclusive OR assignment operator | infix | 2 | right to left |
|= |
Bitwise OR assignment operator | infix | 2 | right to left |
<<= |
Left shift assignment operator | infix | 2 | right to left |
>>= |
Right shift assignment operator sign extension | infix | 2 | right to left |
>>>= |
Right shift assignment operator, zero fill | infix | 2 | right to left |
, |
Multiple evaluation | infix | 1 | left to right |
Napomene:
Ne postoji operator "integer divide" . 5/2
daje 2.5
.
Operatori inkremetiranja ++
i dekrementiranja --
imaju istu semantiku kao i u programskom jeziku C
.
Boolean operatori &&
i ||
sz tzv. "short-circuit"
operatori; ako je prvi operand u &&
false, ili the
prvi operand u ||
je true, drugi operand se neće izračunavati.
Na primjer, u if(i < size && a[i] == 0)...
,
gdje je size
veličina niza, nizu se neće pristupati ako je
i
veliko.
JavaScript automatski konvertuje vrijednosti u odgovarajući tip. Na primjer, kada se string "sabira" sa brojem, broj se konvertuje i string i vrši se nadovezivanje. Ako se string množi brojem, JavaScript prvo pokuša konvertovanje stringa u broj. Ako se string ili broj koriste kao test, automatski se konvertuju u boolean. I tako dalje.
JavaScript nema operator eksplicitne konverzije (coercion operator).
Svaka vrijednost može se konvertovati u njoj ekvivalentnu boolean vrijednost dodavanjem prefiksa
!!
.
Ako su operandi u ==
ili !=
različitih tipova,
JavaScript ih prvo kovertuje u isti tip. Ako su operandi u ===
ili
!==
različitih tipova, oni nisu jednaki.
Numerička poređenja <
, <=
, ==
,
!=
, >=
, >
mogu se koristiti i sa stringovima.
Sva dodjeljivanja su operatori; to znači da imaju vrijednost i mogu se ugnježdavati u veće izraze.
new constructor(arguments)
kreira novi objekat
i poziva konstruktor funkciju da ga inicijalizuje. Za new
samo
(tj. ovo ne važi za druge vrste poziva funkcija), ako nema argumenata, zagrade se ne moraju pisati.
Delete
pokušava da ukloni zadato svojstvo, promjenljivu ili element niza i vraća true ako je uspješan. Promjenjive dekclarisane sa var
ne mogu se izbrisati.
Operator typeof
uzima operand i vraća jedan od sljedečih tipova: "number"
, "string"
, "boolean"
,
"object"
, "function"
ili "undefined"
.
void
ignoriše svoj operand i vraća undefined
.
object instanceof constructor
vraća true
ako je operator sa lijeve strane objekat tipa kreiranog operatorom sa desne strane
(koji mora biti ime konstruktor).
name in object
vraća true
ako je
given object
(koji može biti niz) ima svojstvo sa datim imenom name
.
object . property
vraća vrijednost property
za dati object
ili undefined
ako object
nema svojstvo property
. Svosjtvu property
mora biti dat prost identifikator.
Izraz (expression) u JavaScript-u je kod koji daje rezultat. Izraz može biti prost - jedna konstanta ili promjenljiva.
Operatori sa višim prioritetom (precedence) izvršavaju se prije onih sa nižim prioritetom.
Na primjer, u izrazu 2*3+4*5
, množenje ima veći prioritet od sabiranja.
Ako su operatori istog prioriteta, redosljed određuje asocijativnost. Na primjer, kod 10-5-3
znači (10-5)-3
a ne 10-(5-3)
. Dodjeljivanje je desno asocijativno, pa a=b=c+5
znači a=(b=c+5)
a ne (a=b)=c+5
.
Zagradama se može promijeniti podrazumijevani prioritet.
Naredbe se završavaju simbolom tačka-zarez (semicolon) na kraju linije. Tačka-zarez je obavezna samo da odvoji dvije iki više naredbi u istom redu. Ako naredba zauzima više od jedne linije, vodite računa da se prelamanje vrši na mjestu gdje se prva linije ne može tumačiti kao kompletna naredba.
Dobro: w = a + b +
c + dNije dobro: w = a + b
+ c + d
Statement |
Meaning |
---|---|
izraz; |
Bilo koji izraz može biti naredba; međutima, osim ako izraz
ima neki bočni efekat, izračunata vrijednost se odbacuje. Primjer izraza koji ima boćni efekat: a = b + c; |
{ statements } |
"Složena" naredba, za grupisanje više naredbi. |
if (expression) |
![]() |
if (expression) |
![]() |
while (expression) |
|
for (var in object) |
![]() |
do |
|
for (expr1; expr2; expr3) |
|
|
|
label: statement ; |
Svakoj naredb može se pridružiti labela, ali to obično ima smisla samo u petljama
i switch naredbi. Labele se koriste zajedno sa break i continue naredbama. |
break; |
Izlaz iz najbliže petlje ili switch naredbe. Ne može se koristiti van petlje ili switch naredbe.
|
break label; |
Izlaz iz najbliže petlje ili switch naredbe na labelu. Ne može se koristiti van petlje ili switch naredbe |
continue; |
Vraća se na početak najbliže petlje. Ne može se koristiti van petlje. |
continue label; |
Vraća se na početak najbliže petlje na labelu. Ne može se koristiti van petlje. |
try { |
![]() |
try { |
![]() |
with object |
Use the object as the default prefix for variables in the statement. |
return expression; |
Evaluate the expression and return it as the value of the function. |
return; |
Return from a function. |
Notes:
Naredbe if
, while
, do
, for
,
i with
odnose se na jednu naredbu. Ako želimo da kontrolišu više naredbi, grupišemo ih u složenu naredbu.
Svaki slučaj (case) u switch
naredbi može sadržati više naredbi;
Naredba switch
ima semantiku kao u programskom jeziku C
. Obratiti pažnju šta želite i koristite break
na kraju svake grupe naredbi.
Dio default
u switch
naredbi nije obavezan.
Naredba try
pokušava da izvrši blok naredbi; ako ima greške u
bilo kojoj tački u vrijeme izvršavanja, kontrola se smjesta
prenosi u catch
blok.
Aik oto nje prikazano ovdje, try
naredba može imati više
catch
blokova; u tom slučaju, format svakog catch bloka (osim možda posljednjeg) je catch (identifier if expression)
{...}
expression
true. Samo će se prvi uspješni catch
blok izvršiti.
Kada try
naredba ukllučuje finally
, tada
će se taj blok obavezno izvršiti, bez obzira na try
ili catch
dio. Na primjer, ako try
dio sadrži return
naredbu, povratak če biti odložen dok se ne izvrši finally
dio.
Funkcija je dio koda koji se može pozvati ("invoked", "called"). Funkcije se obično
definiću u <head>
elementu HTML dokumenta, da budemo sigurni da je dfinisina prije nego što je upotrebljena. Funkcije mogu biti ugnježedene unutra drugih funkcija. .
Primjer poziva funkcije:function average(x, y) { // x and y are formal parameters var sum; // this declares sum as a local variable g = x; // this declares g as a global variable sum = g + y; return sum / 2; }
avg = average(5, 10);
Definisanje funkcije
Funkcija square
može biti definisana na bilo koji od sljedećih načina:
function square(x) { return x * x; }
var square = new Function("x", "return x * x;");
var square = function(x) { return x * x; };
var square = function sqr(x) { return x * x; };
(1) je naredba funkcije (function statement). Ona može biti postavljena kao top-level
kod u HTML dokumentu ili kao top-level naredba unutra druge funkcije.
Ova naredba ne može biti u okviru drugog tipa naredbi kakve su petlje ili složena naredba. Riječ var
se ne koristi (osim možda u tijelu funkcije).
(2) koristi Function()
konstruktor. Ovaj konstruktor može imati proizvoljan broj argumenata tipa string; posljednji argument je tijelo funkcije a prethodni argumenti su formalni parametri. Kako je tijelo funkcije dato kao string, moguče je koristiti string metode za konstruisanje tijela funkcije.
(3) koristi function literal. Funkcije su objekt prve klase (first-class objects).
To znači da je funkcija vrijednost podatka i može se koristiti kao bilo koji podataka: dodjeljivati promjenljivoj, predati je kao parametar, itd.
je anonimni function literal, koji u ovom primjeru dodjlejujemo promjenljivoj square
.
(4) je isti kao (3), ali sa privremenim imenom funkcije sqr
.
Privremeno ime funkcije dostupno je samo unutar tijela funkcije, gdje se može
koristiti za rekurzivne pozive. Konačni rezultat je i dalje anonimna funkcija.
Funkcije mogu biti definisane unutar drugih funkcija i lokalne su za funkciju koja ih sadrži:
Funkcije su podacifunction hypotenuse(x, y) { function square(x) { return x * x; } return Math.sqrt(square(x) + square(y)); }
Funcije mogu biti dodijeljene promjenljivim:
Funkcija može biti dodijeljena svojstvu i tada se naziva metodom (method). Unutar metoda,var square2 = square; result = square2(25);
myArray[10] = square;
result = myArray[10](25);
this
se odnosi na call object, tj. na objekat na koji se odnosi svojstvo. .
myRect = { width: 8,
height: 9, area: function() { return this.height * this.width; } } document.write(myRect.area());
Funkcija može biti predata kao parametar funkcije:
myArray.sort(function(a,b) { return a - b; });
Functions can have properties:
myFunction.callCount = 0;
function myFunction() { myFunction.callCount++; ...whatever...; }
Još neke činjenice o funkcijama
Primitivne vrijednosti (number
, string
, boolean
)
predaju se po vrijednosti; objekti se predaju po referenci.
Unutar tijela funkcije, arguments
je specijalni objekat koji sadrži
stvarne parametre koji us predati funkciji. Iako arguments
nije niz, može se koristiti arguments.length
za određivanje broja argumenata i
arguments[i]
da se pristupi itom argumentu. Upotreba arguments
ima isti efekat kao upotreba odgovarajućih imenovanih argumenata.
Može se koristiti arguments
za funkcije sa promjenljivim brojem argumenata. Pored toga, arguments.callee
se odnosi na samu funkciju što se može koristiti za kreiranje anonimnih rekurzivnih funkcija:
function(n) { return n <= 1 ? 1 : n * arguments.callee(n
- 1); }
Oba myFunction.call(myObject, arg0, ..., argN)
myFunction.apply(myObject, arg0, ..., argN)
myFunction
kao metod myObject
;
tj. this
se postavlja na myObject
prije izvršavanja.
Svojstva
Objekat ima svojstva a svojstva imaju vrijednosti. Svojstvo (property) je u osnovi promjenljiva koja je zakačena za objekat i može se dodavati ili brisati iz objekat u bilo kom trenutku.
Ako znate ime svojstva, može mu pristupiti koriteći sljedeču notaciju:
myObject.myProperty
, owner.name
, myCar.make
.
Ako ne znamo ime svojstva, možemo koristiti sljedeču notaciju: teacher[course]
,
teacher["CIT" + number]
Kreiranje objekata
Novi "blank" objekat kreiramo sa:
var myCar = new Object();
Nova polja mogu se dodati na sljedeći način:
myCar.make = "Pontiac"; myCar.year
= 1996;
Objekat se može kreirati primjenom "objekat literala":
var myCar = { make: "Pontiac",
year: 1996 };
Objekat se može kreirati primjenom konstruktora koji ste napisali:
var myCar = Car("Pontiac", 1996);
where:
function Car(m, y) { this.make = m; this.year
= y; }
Poželjno je napisati konstruktor ako želimo definisati više sličnih objekata.
U konstruktoru ključna riječ this
(ovdje je obavezna) odnosi se na novi objekat.
Podrazumijevano, konstruktor vraća kreirani objekat this
, ali se eksplicitno može
vratiti neki drugi objekat.
Kada je objekat kreiran pozivom konstruktora, test object
instanceof constructor
myCar
instanceof Car
true
. Uobičajeno je imena konstruktora pisati velikim početnim slovom.
Prototipovi objekata
Svaki JavaScript objekat pripada klasi, a svaka klasa ima prototip.
Svojstva objekta pripadaju samom objektu. Ako je potrebno svosjtvo ili funkcija zajedničko za sve instance klase, dodajemo ga u prototip klase. Prototip svojstva slična su static
vrijednostima i metodima u jeziku Java.
Na primjer, da bi se osigurali da sva vozila (Car
) imaju 4 točka, možemo napisati:
Car.prototype.wheelCount = 4;
Pojedinom objektu metod možemo dodati na sljedeči način:
myCar.age = function() { return 2002 - this.year;
}
Svim instancama klase metod dodajemo na sljedeći način:
Car.prototype.age = function() { return
2002 - this.year; }
Metod dodajemo klasi na sljedeći način:
Car.prototype.fuel = function() { return
"gasoline"; }
Ključna riječ this
ne može se koristiti sa metodima koji pripadaju klasi.
Za čitanje (read) svojstva, npr. myObj.myProp
,
JavaScript prvo provjerava da li dati objekat myObj
ima svojstvo
i ako ima vraća vrijednost. U suprotnom, provjerava da li prototip objekta ima svosjstvo.
Međutim, za upisivanje (write) vrijednosti svojstva, JavaScript samo provjerava sam objekata a ne koristi njegov prototip. Za svojstva naslijeđena od prototipa, morate im direktno pristupiti, npr. myObj.prototype.myProp
.
Ugrađene (built-in) klase kao String
i Date
takođe imaju prototipove i mogu ime se dodavati nova svojstva.
Svaki objekat iz svog prototipa nasljeđuje (inherits) toString()
metod
koji konvertuje objekat u string, ali rezultat obično nije od koristi.
Metod toString()
se može redefinisati ( override).
Niz je objekat sa nekim specijalnim osobinama.
Kreiranje niza može se uraditi na sljedeći način (npr. niz a
):
var a = new Array(); // an array with
no elements (initially)
var a = new Array(10); // an array with 10 undefined elements
var a = new Array("red", 0xFFFF00, "green"); //
three elements, as given
var a = ["red", 0xFFFF00, "green"]; //using an
array literal
Indeksi niza počinju od nule; a[0]
je prvi element, a[a.length
- 1]
length
svojstvo.
length
se automatski održava. Ako smanjimo length
,
neke elemente odbacujemo a ako povećavamo novi elementi imačevrijednsot undefined
.
Dodavanje elementa nizu obavlja se prosto dodjeljivanjem, npr. a[5000]=1;
0
do 232-1
. Elemente iz niza možemo brisati primjenom delete
operatora. Brisanje elementa ne mijenja dužinu niza niti mijenja lokaciju preotsalih elemenata.
Metodi za nizove
join()
join(string)
string
kao separatorom.reverse()
sort()
sort(function)
function
ima dva argumenta,
i vraća negativan ako je njegov prvi argument "manji od" drugog, nulu, ako su jednaki i pozitivan broj ako je
prvi "veći od" drugog. concat(arg1, ..., argN)
or concat([arg1, ..., argN])
arg1, ..., argN
.slice(start, end)
start
do
end - 1
splice(start)
start
do kraja niza
i vraća ih kao novi niz.splice(start, count)
count
elemenata iz niza, počevši od indeksa
start
i vraća ih u novom nizu. splice(start, count, value1, ..., valueN)
count
elemenata iz niza, počevši od indeksa
start
i zamjenjuje ih novim elementima value1,
..., valueN
. Uklonjeni elementi vraćaju se kao novi niz. push(value1, ..., valueN)
value1, ..., valueN
na kraj niza; vraća novu dužinu niza
pop()
unshift(value1, ..., valueN)
value1, ..., valueN
na početak
niza; vraća novu dužinu niza. shift()
toString()
Tip string
je primitivna vrijednost koja sadrži niz od nula ili više karaktera.
String
(sa velikim početnim slovom) je wrapper objekat za tip string
.
Metodi u ovoj sekciji su u stvari String
metodi, ali JavaScript konvertuje po potrebi.
Stringovi imaju length
svojstvo - broj karaktera u stringu.
Stringovi se mogu nadovezivati (i tako prave novi string) prmjenom +
operatora.
String metodi
Neki važniji metodi za rad sa strongovimaHere are some of the more important methods on strings. Others are
charAt(n)
n
-ti karakter stringa.charCodeAt(n)
n
-tog
karaktera stringa.concat(string1, ..., stringN)
fromCharCode(c1, ..., cN)
indexOf(substring)
substring
datog stringa ili -1
ako nije pronađen.indexOf(substring, start)
substring
u datom stringu koji je na poziciji iza start
,
ili -1
ako nije pronađen.lastIndexOf(substring)
lastIndexOf(substring, start)
indexOf
, ali kreće od kraja stringa.localeCompare(string)
string
manji, jednak ili veči od datog stringa, u skladu sa locale-specific redosljedom.match(regexp)
null
ako poklapanja nema. Na uspješnom poklapanju:
g
(global) postavljeno, niz sadrži poklopljene podstringove.g
nije postavljen, lokacija 0 u nizu sadrži poklopljeni tekst
a preostale lokacije sadrže tekst poklopljen sa podizrazima u zagradama. Svojstvo index
daje poziciju prvog karaktera poklapanja.replace(regexp, replacement)
replacement
.
search(regexp)
-1
ako nema poklapanja.
/[a-zA-Z][a-zA-Z0-9_]/
.
Regularni izraz može se kreirati predajom string RegExp konstruktoru, npr new RegExp("[a-zA-Z][a-zA-Z0-9_]")
.Karakteri u regularnom izrazu klasifikovani su na sljedeći način:
\ | ( ) [ { ^ $ * + . ?
\\ \| \( \)
\[ \{ \^ \$ \* \+ \. \?
i
takođe:
\0
The NUL character, \u0000
[\b]
Backspace, \u0008
(special
syntax)
\t
Tab, \u0009
\n
Newline, \u000A
\v
Vertical tab, \u000B
\f
Form feed, \u000C
\r
Carriage return, \u000D
\xHH
The character specified by
the hex number HH
\uHHHH
The character specified
by the hex number HHHH
\cX
The control character ^X
\w
A word character; same as [a-zA-Z0-9_]
\W
A nonword character; same as [^a-zA-Z0-9_]
\s
A whitespace character\S
A non-whitespace character\d
A digit; same as [0-9]
\D
A nondigit; same as [^0-9]
.
(Not escaped) Any character except
a line terminator.Sljedeća tabela predstavlja značenje metakaraktera:
Izraz | Znaćenje | Primjer | Objašnjenje |
---|---|---|---|
a literal character | That same character | M |
The capital letter M |
XY |
An X followed by a Y |
cat |
The three characters c a t , in that order |
[X-Y] |
Any one character between X and Y ,
inclusive |
[0-9] [a-zA-Z] |
Any decimal digit; Any letter |
[^X-Y] |
Any one character not between X and Y ,
inclusive |
|
Any non-letter |
X* |
Zero or more occurrences of X |
\s* |
Any amount of whitespace |
X+ |
One or more occurrences of X |
\s+ |
At least one whitespace character |
X? |
An optional X |
dogs? |
Either dog or dogs |
X{n,m} |
From n to m occurrences of X |
his{2,4} |
hiss or hisss or hissss |
X{n,} |
n or more occurrences of X |
his{2,} |
hiss or hisss or hissss or ... |
X{n} |
Exactly n occurrences of X |
his{2} |
hiss |
X|Y |
Either X or Y |
|
Either or
|
^X |
X at the beginning of the string |
^[A-Z] |
An initial capital letter (the ^ itself matches the empty
string) |
X
$ |
X at the end of the string |
[\.\?!]$ |
Ends with a period, question mark or exclamation point (the $
itself matches the empty string) |
\b |
The empty string between a word character (\w ) and a nonword
character(\W ) |
\bC\b |
The word C , as in the language |
\B |
An empty string that is not between a word character (\w )
and a nonword character(\W ) |
comput\B |
The initial part of the words comput er, comput ing,
etc. |
(?=pat) |
Look ahead to make sure that the pattern pat will
match next, but do not count it in the matched part |
\w+(?= ) |
A word, provided it is followed by a space |
(?!pat) |
Look ahead to make sure that the pattern pat will
not match next |
\w+(?!- ) |
A word, provided it is not followed by a hyphen |
(X) |
Group the expression X into a single unit, and remember
what it matches |
(////.*$) |
A // -style comment (keep for later reference) |
(?:X) |
Group the expression X into a single unit, but do
not remember what it matches |
(?:////.*$) |
A // -style comment (discard it) |
Ne uključujte dodatne simbole bjeline u regularne izraze!
Poslije regulranog izraza, i
označava case-insensitive poklapanje(npr.
/javascript/i
).Simbol g
poslije regularnog izraza ("global")
znači da se na zaustavimo poslije prvog poklapanja. Simbol m
znači "multiline mode:", dok ^
će poklapati pošetak stringa sa poćetkom linije. $
će poklapati sa krajem stringa.
string.search(pattern)
string
koja se poklapa sa pattern
ili -1
ako pattern nije nađen.
Ako je zadat g
, ignoriše se.
string.replace(pattern, replacement)
string
za pattern
i ako je nađen, zamjenjuje ga sa replacement
. Ako je zadata
g
, metod zamjenjuje sva pojavljivanja argumenta pattern
argumentom replacement
.
Ako pattern
sadrži grupe sa zagradama (parenthesized groups), tada
replacement
može koristiti $1
za predstavljanje prve
grupe poklapanja, $2
za drugu grupu, itd.string.match(pattern)
match
uvijek vraća niz. Ako je g
flag postavljen
match
vraća niz poklopljenih podstringova. Ako
g
flag nije postavljen, match
vraća niz čiji je prvi element
poklopljeni podstring a čiji je n-ti element dio poklopljen sa
n-tom grupom. Niz ima length
svojstvo, index
svojstvo koje čuva početnu poziciju i input
svosjtvo (koje čuva string
).string1.split(string2_or_pattern)
string1
,
gdje je svako pojavljivanje string2_or_pattern
razdvaja podstringove u string1
.pattern.exec(string)
exec
vraća niz čiji prvi element poklopljeni podstring
i čiji n-ti element je dio poklopljen sa n-tom
grupom. Ako nema poklapanja, exec
vraća null
.
Ako je g
flag postavljen, exec
takože modificira lastIndex
svojstvo pattern
na poziciju karaktera neposredno iza poklapanja.
(ili na 0
ako nema poklapanja), pa ako se pattern ponovi koristi,
traženje se nastavlja od tačke gdje je prekinuto. pattern.test(string)
true
ako je poklapanje uspješno i null
inače.
g
flag je obrađen na isti način kao i za exec
.
Drugi dio: Client-Side JavaScript |